//#include "ObjMeshManager.h"
//#include "AIRoom.h"
//#include "DX11ErrorReport.h"
//#include "DX11ShaderManager.h"
//#include "ScreenManager.h"
//#include "DX11TextureManager.h"
//#include "LightingManager.h"
//#include "OOBB.h"
//#include "D3DXVECTOROperators.h"
//
//AIRoom::AIRoom()
//{
//	m_colour = D3DXVECTOR4(1.0f, 1.0f, 1.0f, 1.0f);
//	m_shaderName = "DefaultTexture";
//	D3DXMatrixIdentity(&m_world);
//}
//
//AIRoom::~AIRoom()
//{
//
//}
//
//void AIRoom::Draw()
//{
//	// set lights
//	for (int i = 0; i != TheLightingManager::Instance()->GetNumberOfLights(); i++)
//	{
//		Light l = TheLightingManager::Instance()->GetLight(i + 1);
//		m_cb.light[i].ambient = l.ambient;
//		m_cb.light[i].colour = l.colour;
//		m_cb.light[i].direction = l.direction;
//		m_cb.light[i].attenuation = l.attenuation;
//		m_cb.light[i].range = l.range;
//		m_cb.light[i].enabled = l.enabled;
//		m_cb.light[i].position = l.position;
//		m_cb.light[i].pad = l.pad;
//	}
//
//	D3DXMatrixIdentity(&m_world);
//	D3DXMatrixTranslation(&m_world, m_position.x, m_position.y, m_position.z);
//	//while (!m_transformationMatrices.empty())
//	//{
//	//	D3DXMATRIX mat = m_transformationMatrices.top();
//	//	m_world *= mat;//m_transformationMatrices.top();
//	//	m_transformationMatrices.pop();
//	//}
//	m_cb.m_outputColour = m_colour;
//	//m_cb.m_outputColour = D3DXVECTOR4(0.0f, 1.0f, 0.0f, 1.0f);
//
//	TheScreenManager::Instance()->SetBuffers(m_pVertexBuffer, m_pIndexBuffer);
//
//	D3DXMatrixTranspose(&m_cb.m_world, &m_world);
//	D3DXMatrixTranspose(&m_cb.m_view, &TheScreenManager::Instance()->GetViewMatrix());
//	D3DXMatrixTranspose(&m_cb.m_projection, &TheScreenManager::Instance()->GetProjectionMatrix());
//
//	D3DXMatrixTranspose(&m_cb.m_lightViewMatrix, &TheLightingManager::Instance()->GetLightViewMatrix());
//	D3DXMatrixTranspose(&m_cb.m_lightProjMatrix, &TheLightingManager::Instance()->GetLightProjMatrix());
//
//	TheScreenManager::Instance()->GetDeviceContext()->UpdateSubresource(m_pConstantBuffer, 0, NULL, &m_cb, 0, 0);
//
//	TheScreenManager::Instance()->GetDeviceContext()->VSSetShader(
//		TheDX11ShaderManager::Instance()->UseShader(m_shaderName).first, NULL, 0);
//	TheScreenManager::Instance()->GetDeviceContext()->PSSetShader(
//		TheDX11ShaderManager::Instance()->UseShader(m_shaderName).second, NULL, 0);
//
//	TheScreenManager::Instance()->GetDeviceContext()->VSSetConstantBuffers(0, 1, &m_pConstantBuffer);
//	
//	TheScreenManager::Instance()->GetDeviceContext()->PSSetConstantBuffers(0, 1, &m_pConstantBuffer);
//
//	// this will be used for mutliple groups in a mesh - each with a different texture
//	bool notCalled = false;
//	int counter = 0;
//
//	TheScreenManager::Instance()->GetDeviceContext()->PSSetShaderResources(0, 1, 
//		&TheDX11TextureManager::Instance()->UseTexture(L"../../Assets/default_texture.png"));
//	//TheScreenManager::Instance()->GetDeviceContext()->PSSetShaderResources(1, 1, &m_secondTextureResource);
//
//	ID3D11SamplerState* sampState = TheDX11TextureManager::Instance()->UseDefaultSamplerState();
//	TheScreenManager::Instance()->GetDeviceContext()->PSSetSamplers(0, 1, &sampState);
//	
//
//	TheScreenManager::Instance()->GetDeviceContext()->DrawIndexed(m_numOfIndices, 0, 0);
//
//	//m_mesh.Draw();
//}
//
//void AIRoom::Update()
//{
//
//}
//
//bool AIRoom::Generate(const std::string& filename, const D3DXVECTOR2& halfSize, const D3DXVECTOR3& pos, const RoomDoors& rd)
//{
//	//m_mesh.Load("room", filename, L"Tutorial02.fx");
//
//	m_size = halfSize;
//	m_position = pos;
//
//	D3DXVECTOR2 doorSize = D3DXVECTOR2(5, 10);
//
//	//// generate vertices depending on size, will be different for each because of doors
//	//File* f = new File();
//	//if (!f->OpenRead(filename))
//	//{
//	//	DX11ErrorMsg(L"Failed to open Obj File", L"AIROOM generate", MB_OK);
//	//	return false;
//	//}
//	//
//	//std::string lineContents;
//	//std::vector<D3DXVECTOR3> vertexData;
//	//std::vector<D3DXVECTOR2> uvData;
//	//std::vector<D3DXVECTOR3> normalData;
//
//	//std::vector<DWORD> indexData;
//	//std::vector<VertexData> finalVerts;
//
//	//D3DXVECTOR3 roomMaxCorner;
//
//	//while (f->GetString(&lineContents))
//	//{
//	//	Strings str = Split(lineContents, ' ');
//
//	//	if (str[0] ==  "v")
//	//	{
//	//		vertexData.push_back(D3DXVECTOR3(ToFloat(str[1]), ToFloat(str[2]), ToFloat(str[3])));
//	//		
//	//	}
//	//	else if (str[0] == "f")
//	//	{
//	//		if (str.size() != 4)
//	//		{
//	//			DX11ErrorMsg(L"Did not triangulate mesh", L"Obj Mesh Error", MB_YESNO);
//	//		}
//	//		else
//	//		{
//	//			//for (int i = 1; i < 4; i++)
//	//			//{
//	//				//Strings faceStr = Split(str[i], '/');
//	//				// add assert
//	///*				for (int j = 0; j != 3; j++)
//	//				{
//	//					indexData.push_back(ToInt(faceStr[j]) - 1);
//	//				}*/
//	//				
//	//				for (int i = 1; i < 4; i++)
//	//				{
//	//					Strings faceStr = Split(str[i], '/');
//	//					assert(faceStr.size() == 3);
//	//					// add assert
//	//					//indexData.push_back(ToInt(faceStr[0].c_str()) - 1);
//	//					//normalData.push_back(ToInt(faceStr[2].c_str()) - 1);
//	//					//uvData.push_back(ToInt(faceStr[1].c_str()) - 1);
//
//	//					indexData.push_back(ToInt(faceStr[0].c_str()) - 1);
//	//					indexData.push_back(ToInt(faceStr[1].c_str()) - 1);
//	//					indexData.push_back(ToInt(faceStr[2].c_str()) - 1);
//	//				}
//	//			//}
//	//		}			
//	//	}
//	//	else if (str[0] == "vn")
//	//	{
//	//		normalData.push_back(D3DXVECTOR3(ToFloat(str[1]), ToFloat(str[2]), ToFloat(str[3])));
//
//	//	}
//	//	else if (str[0] == "vt")
//	//	{
//	//		uvData.push_back(D3DXVECTOR2(ToFloat(str[1]), ToFloat(str[2])));
//	//	}
//	//}
//
//	////int numOfTris = indexData.size() / 3;
//	//std::vector<DWORD> finalIndices;
//	//for (int i = 0; i != indexData.size(); i++)
//	//{
//	//	finalIndices.push_back(i);
//	//}
//
//	//for (int i = 0; i != indexData.size()-3; i+=3)
//	//{
//	//	finalVerts.push_back(VertexData());
//	//	finalVerts.back().m_pos = vertexData[indexData[i]];
//	//	finalVerts.back().m_texCoord = uvData[indexData[i+1]];
//	//	finalVerts.back().m_normal = normalData[indexData[i+2]];
//	//}
//
//	//m_numOfIndices = finalIndices.size();
//	//
//	//D3D11_BUFFER_DESC bd;
//	//D3D11_SUBRESOURCE_DATA initData;
//	//TheScreenManager::Instance()->InitBuffers(m_pVertexBuffer, m_pIndexBuffer, bd, initData, 
//	//	finalVerts, finalIndices, &m_pConstantBuffer);
//
//	//vertexData.clear();
//	//uvData.clear();
//	//normalData.clear();
//	//indexData.clear();
//	//finalVerts.clear();
//	//delete f;
//	//return true;
//
//		
//	// TODO: find corners of box and set it to the size
//	// TODO: make rooms for n/e/s/w doors open/closed
//	// TODO: generate paths between rooms (do in maze.h)
//
//	std::vector<VertexData> m_vertData;
//	std::vector<DWORD> m_indexData;
//	std::vector<int> m_uvData;
//	std::vector<int> m_normalData;
//	std::vector<D3DXVECTOR2> m_uvIndices;
//	std::vector<D3DXVECTOR3> m_normalIndices;
//
//	RoomCorners meshBoxBounds;
//	RoomCorners convertedBounds;
//
//	File* file = new File;
//	if (!file->OpenRead(filename))
//	{
//		DX11ErrorMsg(L"Cannot open obj file", L"Obj Load Error", MB_OK);
//		return false;
//	}
//
//	std::string lineContents;
//
//	while (file->GetString(&lineContents))
//	{
//		Strings str = Split(lineContents, ' ');
//
//		if (str[0] ==  "v")
//		{
//			m_vertData.push_back(VertexData());
//			m_vertData.back().m_pos = D3DXVECTOR3(ToFloat(str[1]), ToFloat(str[2]), ToFloat(str[3]));
//
//			if (meshBoxBounds.maxPoints.x < m_vertData.back().m_pos.x)
//			{
//				meshBoxBounds.maxPoints.x = m_vertData.back().m_pos.x;
//			}
//			if (meshBoxBounds.maxPoints.y < m_vertData.back().m_pos.y)
//			{
//				meshBoxBounds.maxPoints.y = m_vertData.back().m_pos.y;
//			}
//			if (meshBoxBounds.maxPoints.z < m_vertData.back().m_pos.z)
//			{
//				meshBoxBounds.maxPoints.z = m_vertData.back().m_pos.z;
//			}
//		}
//		else if (str[0] == "f")
//		{
//			if (str.size() != 4)
//			{
//				DX11ErrorMsg(L"Did not triangulate mesh", L"Obj Mesh Error", MB_YESNO);
//			}
//			else
//			{
//				for (int i = 1; i < 4; i++)
//				{
//					Strings faceStr = Split(str[i], '/');
//					// add assert
//					m_indexData.push_back(ToInt(faceStr[0].c_str()) - 1);
//					m_normalData.push_back(ToInt(faceStr[2].c_str()) - 1);
//					m_uvData.push_back(ToInt(faceStr[1].c_str()) - 1);
//				}
//			}			
//		}
//		else if (str[0] == "vn")
//		{
//			m_normalIndices.push_back(D3DXVECTOR3(ToFloat(str[1]), ToFloat(str[2]), ToFloat(str[3])));
//
//		}
//		else if (str[0] == "vt")
//		{
//			m_uvIndices.push_back(D3DXVECTOR2(ToFloat(str[1]), ToFloat(str[2])));
//		}
//	}
//
//	// set size of box
//	for (int i = 0; i != m_vertData.size(); i++)
//	{
//		if (!(m_vertData[i].m_pos.x < meshBoxBounds.maxPoints.x && m_vertData[i].m_pos.x > -meshBoxBounds.maxPoints.x))
//		{
//			m_vertData[i].m_pos.x *= halfSize.x;
//			if (!(m_vertData[i].m_pos.z < meshBoxBounds.maxPoints.z && m_vertData[i].m_pos.z > -meshBoxBounds.maxPoints.z))
//			{
//				m_vertData[i].m_pos.z *= halfSize.y;
//			}
//		}
//		else if (!(m_vertData[i].m_pos.z < meshBoxBounds.maxPoints.z && m_vertData[i].m_pos.z > -meshBoxBounds.maxPoints.z))
//		{
//			m_vertData[i].m_pos.z *= halfSize.y;
//			if (!(m_vertData[i].m_pos.x < meshBoxBounds.maxPoints.x && m_vertData[i].m_pos.x > -meshBoxBounds.maxPoints.x))
//			{
//				m_vertData[i].m_pos.x *= halfSize.x;
//			}
//		}
//	}
//
//	D3DXVec3Mult(&convertedBounds.maxPoints, meshBoxBounds.maxPoints);
//	convertedBounds.maxPoints += pos;
//	// find room nodes and set them
//	// room centre = centre point with y = 0;
//	m_nodes[ROOM_CENTRE].SetPos(D3DXVECTOR3(convertedBounds.maxPoints.x - halfSize.x, 0.0f, convertedBounds.maxPoints.z - halfSize.y));
//	// north = roomcentre.x, maxZ;
//	m_nodes[NORTH].SetPos(D3DXVECTOR3(convertedBounds.maxPoints.x - halfSize.x, 0.0f, convertedBounds.maxPoints.z));
//	// east = maxX, roomcentre.z;
//	m_nodes[EAST].SetPos(D3DXVECTOR3(convertedBounds.maxPoints.x, 0.0f, convertedBounds.maxPoints.z - halfSize.y));
//	// south = roomcentre.x, -maxZ;
//	m_nodes[SOUTH].SetPos(D3DXVECTOR3(convertedBounds.maxPoints.x - halfSize.x, 0.0f, -convertedBounds.maxPoints.z));
//	// west = -maxX, roomcentre.z;
//	m_nodes[WEST].SetPos(D3DXVECTOR3(-convertedBounds.maxPoints.x, 0.0f, convertedBounds.maxPoints.z - halfSize.y));
//
//	std::vector<VertexData> FaceData;
//	unsigned int numOfFaces = m_normalData.size();
//
//	std::vector<DWORD> indexData;
//	unsigned int counter = 0;
//	for (DWORD j = 0; j < numOfFaces; j++)
//	{
//		FaceData.push_back(VertexData());
//
//		FaceData.back().m_pos = m_vertData[m_indexData[j]].m_pos;
//		FaceData.back().m_texCoord = m_uvIndices[m_uvData[j]];
//		FaceData.back().m_normal = m_normalIndices[m_normalData[j]];
//
//		indexData.push_back(j);
//		//counter++;
//	}
//	
//
//
//	m_numOfIndices = indexData.size();
//	
//	D3D11_BUFFER_DESC bd;
//	D3D11_SUBRESOURCE_DATA initData;
//	TheScreenManager::Instance()->InitBuffers(m_pVertexBuffer, m_pIndexBuffer, bd, initData, 
//		FaceData, indexData, &m_pConstantBuffer);
//		
//	m_vertData.clear();
//	m_uvData.clear();
//	m_normalData.clear();
//	m_uvIndices.clear();
//	m_normalIndices.clear();
//	FaceData.clear();
//	indexData.clear();
//	m_indexData.clear();
//	file->CloseFile(filename);
//	return true;
//}
//
//GraphNode& AIRoom::GetNodes(RoomPoint point)
//{
//	return m_nodes[point];
//}
//
//void AIRoom::SetRoomNodePointOpen(RoomPoint point)
//{
//	m_nodes[point].SetRoomPoint(point);
//}
//
////bool AIRoom::Load(File* f)
////{
////	if (f->GetD3DXVECTOR2(&m_size))
////	{
////		DX11ErrorMsg(L"Expected room size", L"AIRoom load function", MB_OK);
////		return false;
////	}
////
////	return true;
////}
////
////const char* AIRoom::GetTypeName() const
////{
////	return "AIRoom";
////}
//
